import { getRawType } from './data.tool'

/**
 * @description 时间
 * @author 张航
 * @date 2020-03-18 12:27:21
 * @version V1.0.0
 */

/**
 * @functionName  date2str
 * @param {Date} date 时间对象
 * @return {String} 时间字符串
 * @description 时间转换为字符串
 * @author 张航
 * @date 2020-03-18 12:36:44
 * @version V1.0.0
 */
export const date2str = (date = new Date()) => {
  let str
  if (Object.prototype.toString.call(date) === '[object Date]') {
    const Y = date.getFullYear()
    const M = date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1
    const D = date.getDate() < 10 ? '0' + (date.getDate()) : date.getDate()
    str = `${Y}-${M}-${D}`
  } else {
    console.warn(`参数"${date}"类型不正确,请传入[Date]类型！`)
    str = ''
  }
  return str
}

/**
 * @functionName  str2date
 * @param {String|Number} str 时间字符串或时间戳
 * @return {Date} 转换成Date数据
 * @description 时间字符串或时间戳转换成Date数据
 * @author 张航
 * @date 2020-03-18 12:36:44
 * @version V1.0.0
 */
export const str2date = (str = '') => {
  let date
  if (Object.prototype.toString.call(str) === '[object String]' || Object.prototype.toString.call(str) === '[object Number]') {
    date = new Date(str)
  } else {
    console.warn(`参数"${str}"类型不正确,请传入[String]或[Number]类型！`)
    date = null
  }
  return date
}

/**
 * @functionName getTimeStamp
 * @param {Date|String|Number} time 时间、时间字符串或时间戳
 * @return {Number} 返回时间戳
 * @description 获取传入的时间或当前时间的时间戳
 * @author 张航
 * @date 2020-03-18 13:08:57
 * @version V1.0.0
 */
export const getTimeStamp = (time = '') => {
  const type = getRawType(time)
  if (type === 'Date') {
    return time.valueOf()
  }

  if (type === 'String' || type === 'Number') {
    return (time ? new Date(time) : new Date()).valueOf()
  }
  console.warn(`参数"${time}"类型不正确,请传入[Date]、[String]或[Number]类型！`)
  return false
}

/**
 * @functionName isMillisecond
 * @param {Number} timeStamp 被检测的时间戳
 * @return {Boolean} 返回判断结果
 * @description 判断时间戳格式是否是毫秒，内部使用
 * @author 张航
 * @date 2020-03-18 13:00:58
 * @version V1.0.0
 */
const isMillisecond = timeStamp => {
  const timeStr = String(timeStamp)
  return timeStr.length > 10
}

/**
 * @functionName isEarly
 * @param {Number} timeStamp 传入的时间戳
 * @param {Number} currentTime 当前时间时间戳
 * @return {Boolean} 返回判断结果
 * @description 判断传入的时间戳是否早于当前时间戳，内部使用
 * @author 张航
 * @date 2020-03-18 12:59:09
 * @version V1.0.0
 */
const isEarly = (timeStamp, currentTime) => {
  return timeStamp < currentTime
}

/**
 * @functionName getHandledValue
 * @param {Number} num 数值
 * @return {String} 处理后的字符串
 * @description 时间处理的补位，如果传入的数值小于10，即位数只有1位，则在前面补充0，内部使用
 * @author 张航
 * @date 2020-03-18 12:57:34
 * @version V1.0.0
 */
const getHandledValue = num => {
  return num < 10 ? '0' + num : num
}

/**
 * @functionName getDate
 * @param {Number} timeStamp 传入的时间戳
 * @param {String} startType 要返回的时间字符串的格式类型（默认为：月-日-时-分）
 *                           传入'year'则返回年开头的完整时间（年-月-日-时-分-秒）
 * @return {String} 时间字符串
 * @description 获取时间字符串，内部使用
 * @author 张航
 * @date 2020-03-18 12:53:08
 * @version V1.0.0
 */
const getDate = (timeStamp, startType) => {
  const d = new Date(timeStamp * 1000)
  const year = d.getFullYear()
  const month = getHandledValue(d.getMonth() + 1)
  const date = getHandledValue(d.getDate())
  const hours = getHandledValue(d.getHours())
  const minutes = getHandledValue(d.getMinutes())
  const second = getHandledValue(d.getSeconds())
  let resStr = ''
  if (startType === 'year') resStr = year + '-' + month + '-' + date + ' ' + hours + ':' + minutes + ':' + second
  else resStr = month + '-' + date + ' ' + hours + ':' + minutes
  return resStr
}

/**
 * @functionName getRelativeTime
 * @param {String|Number} timeStamp 时间戳
 * @return {String} 相对时间字符串
 * @description 生成相对时间
 * @author 张航
 * @date 2020-03-18 12:51:56
 * @version V1.0.0
 */
export const getRelativeTime = (timeStamp = '') => {
  console.log('换算时间')
  // 判断当前传入的时间戳是秒格式还是毫秒
  const IS_MILLISECOND = isMillisecond(timeStamp)
  // 如果是毫秒格式则转为秒格式
  if (IS_MILLISECOND) Math.floor(timeStamp /= 1000)
  // 传入的时间戳可以是数值或字符串类型，这里统一转为数值类型
  timeStamp = Number(timeStamp)
  // 获取当前时间时间戳
  const currentTime = Math.floor(Date.parse(new Date()) / 1000)
  // 判断传入时间戳是否早于当前时间戳
  const IS_EARLY = isEarly(timeStamp, currentTime)
  // 获取两个时间戳差值
  let diff = currentTime - timeStamp
  // 如果IS_EARLY为false则差值取反
  if (!IS_EARLY) diff = -diff
  let resStr = ''
  const dirStr = IS_EARLY ? '前' : '后'
  // 少于等于59秒
  if (diff <= 59) resStr = diff + '秒' + dirStr
  // 多于59秒，少于等于59分钟59秒
  else if (diff > 59 && diff <= 3599) resStr = Math.floor(diff / 60) + '分钟' + dirStr
  // 多于59分钟59秒，少于等于23小时59分钟59秒
  else if (diff > 3599 && diff <= 86399) resStr = Math.floor(diff / 3600) + '小时' + dirStr
  // 多于23小时59分钟59秒，少于等于29天59分钟59秒
  else if (diff > 86399 && diff <= 2623859) resStr = Math.floor(diff / 86400) + '天' + dirStr
  // 多于29天59分钟59秒，少于364天23小时59分钟59秒，且传入的时间戳早于当前
  else if (diff > 2623859 && diff <= 31567859 && IS_EARLY) resStr = getDate(timeStamp)
  else resStr = getDate(timeStamp, 'year')
  return resStr
}


/**
 * @functionName isLeapYear
 * @param {Number} year 年份
 * @return {Boolean} 返回结果
 * @description 判断年份是否为闰年
 * @author 张航
 * @date 2020-04-20 10:50:03
 * @version V1.0.0
 */
export const isLeapYear = (year = 0) => {
  if (year % 4 === 0 && year % 100 !== 0 || year % 400 === 0) {
    return true
  }
  return false
}

/**
 * @description 根据秒转天、小时、分、秒
 * @author 穆宏宇
 * @date 2020-10-15 15:55:59
 * @param
 * @return
 * */
export const  timeStamp = ( second_time ) => {
  let time = parseInt(second_time) + '秒'
  if( parseInt(second_time )> 60){
    let second = parseInt(second_time) % 60;
    let min = parseInt(second_time / 60);
    time = min + '分' + second + '秒'
    if( min > 60 ){
      min = parseInt(second_time / 60) % 60;
      let hour = parseInt( parseInt(second_time / 60) /60 )
      time = hour + '小时' + min + '分' + second + '秒'
      if( hour > 24 ){
        hour = parseInt( parseInt(second_time / 60) /60 ) % 24;
        let day = parseInt( parseInt( parseInt(second_time / 60) /60 ) / 24 )
        time = day + '天' + hour + '小时' + min + '分' + second + '秒'
      }
    }
  }
  return time
}
